package com.redepronik.negosysdis.invfac.controller;

import static com.redepronik.negosys.utils.Utils.divide;
import static com.redepronik.negosys.utils.Utils.fechaFormatoDate;
import static com.redepronik.negosys.utils.Utils.iva;
import static com.redepronik.negosys.utils.Utils.newBigDecimal;
import static com.redepronik.negosys.utils.Utils.parametro;
import static com.redepronik.negosys.utils.Utils.presentaMensaje;
import static com.redepronik.negosys.utils.Utils.redondear;
import static com.redepronik.negosys.utils.Utils.redondearTotales;
import static com.redepronik.negosys.utils.Utils.timestamp;

import java.io.Serializable;
import java.math.BigDecimal;
import java.util.ArrayList;
import java.util.Calendar;
import java.util.Date;
import java.util.GregorianCalendar;
import java.util.List;

import javax.annotation.PostConstruct;
import javax.faces.application.FacesMessage;
import javax.faces.event.ActionEvent;

import org.primefaces.context.RequestContext;
import org.primefaces.event.CellEditEvent;
import org.primefaces.event.SelectEvent;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.context.annotation.Scope;
import org.springframework.security.core.context.SecurityContextHolder;
import org.springframework.stereotype.Controller;

import com.redepronik.negosys.invfac.entity.Bodega;
import com.redepronik.negosys.invfac.entity.Detalleegreso;
import com.redepronik.negosys.invfac.entity.Egreso;
import com.redepronik.negosys.invfac.entity.Entrada;
import com.redepronik.negosys.invfac.entity.Kardex;
import com.redepronik.negosys.invfac.entity.Local;
import com.redepronik.negosys.invfac.entity.Pagoentrada;
import com.redepronik.negosys.invfac.entity.Producto;
import com.redepronik.negosys.invfac.entity.Tipopago;
import com.redepronik.negosys.invfac.entityAux.CantidadFactura;
import com.redepronik.negosys.invfac.entityAux.EntradaReporte;
import com.redepronik.negosys.invfac.entityAux.FacturaReporte;
import com.redepronik.negosys.invfac.entityAux.PersonaCedulaNombre;
import com.redepronik.negosys.invfac.service.EgresoService;
import com.redepronik.negosys.invfac.service.KardexService;
import com.redepronik.negosys.invfac.service.LocalService;
import com.redepronik.negosys.invfac.service.ProductoService;
import com.redepronik.negosys.invfac.service.TipoDocumentoService;
import com.redepronik.negosys.invfac.service.TipoPagoService;
import com.redepronik.negosys.rrhh.entity.Empleadocargo;
import com.redepronik.negosys.rrhh.entity.Persona;
import com.redepronik.negosys.rrhh.service.ClienteService;
import com.redepronik.negosys.rrhh.service.EmpleadoService;
import com.redepronik.negosysdis.invfac.report.EgresoReport;

@Controller
@Scope("session")
public class NotaEntregaBean implements Serializable {

	private static final long serialVersionUID = 1L;

	@Autowired
	private EgresoService egresoService;

	@Autowired
	private ProductoService productoService;

	@Autowired
	private KardexService kardexService;

	@Autowired
	private ClienteService clienteService;

	@Autowired
	private LocalService localService;

	@Autowired
	private TipoDocumentoService tipoDocumentoService;

	@Autowired
	private TipoPagoService tipoPagoService;

	@Autowired
	private EmpleadoService empleadoService;

	@Autowired
	private EgresoReport egresoReport;

	private List<Tipopago> listTiposPago;
	private List<EntradaReporte> listaEntradaReporte;
	private List<PersonaCedulaNombre> listaVendedores;
	private List<Local> listaLocales;

	private Egreso egreso;
	private Persona cliente;
	private Empleadocargo vendedor;
	private Entrada entrada;
	private Pagoentrada pagosEntrada;
	private Tipopago tiposPago;
	private Date fechaInicio;

	private List<Producto> listaProductoBusqueda;
	private String criterioProductoBusqueda;
	private Producto producto;

	private List<FacturaReporte> listaFacturaReporte;
	private FacturaReporte facturaReporte;
	private CantidadFactura cantidadFacturaCalculos;
	private CantidadFactura cantidadFacturaPresentar;
	private BigDecimal restante;
	private BigDecimal restanteAux;
	private BigDecimal cambio;
	private BigDecimal totalMonto;

	private Integer cantidad;
	private BigDecimal nuevoPrecio;

	private Bodega bodega;
	private Integer fila;

	private boolean bn = true;
	private boolean bnLocal;

	private List<Persona> listaClienteBusqueda;
	private String criterioClienteBusqueda;

	public NotaEntregaBean() {
		listaProductoBusqueda = new ArrayList<Producto>();
		listTiposPago = new ArrayList<Tipopago>();
		listaEntradaReporte = new ArrayList<EntradaReporte>();

		cliente = new Persona();
		entrada = new Entrada();
		pagosEntrada = new Pagoentrada();
		tiposPago = new Tipopago();
		fechaInicio = new Date();
		producto = new Producto();
		listaFacturaReporte = new ArrayList<FacturaReporte>();
		facturaReporte = new FacturaReporte();
		cantidadFacturaCalculos = new CantidadFactura();
		cantidadFacturaPresentar = new CantidadFactura();
		restante = newBigDecimal();
		cambio = newBigDecimal();
		totalMonto = new BigDecimal("0");
	}

	public void calcularDescuentoDolares() {
		egresoService.calcularDescuentoDolares(facturaReporte);
	}

	public void calcularDescuentoPorcentaje() {
		egresoService.calcularDescuentoPorcentaje(facturaReporte);
	}

	public void calcularEntrada() {
		EntradaReporte entradaReporte = new EntradaReporte();
		if (entrada.getFechapago() != null) {
			pagosEntrada.setCuota(entrada.getCuota());
			pagosEntrada.setTipopago(tiposPago);
			pagosEntrada.setFechapago(timestamp(entrada.getFechapago()));
			pagosEntrada.setPagado(true);
			entrada.setPagado(true);
			entrada.setSaldo(new BigDecimal("0"));
			entrada.setFechamora(fechaFormatoDate("01-01-1900"));
			entradaReporte.setFechaPago(entrada.getFechapago());
			entradaReporte.setPagado(true);
			entrada.addPagoentrada(pagosEntrada);
			egreso.addEntrada(entrada);
		} else if (tiposPago.getTipopagoid() == 3) {
			entrada.setPagado(false);
			entrada.setSaldo(entrada.getCuota());
			entrada.setFechamora(fechaFormatoDate("01-01-1900"));
			pagosEntrada.setCuota(entrada.getCuota());
			pagosEntrada.setTipopago(tiposPago);
			pagosEntrada.setFechapago(timestamp("01-01-1900"));
			pagosEntrada.setPagado(false);
			entrada.addPagoentrada(pagosEntrada);
			egreso.addEntrada(entrada);
			entradaReporte.setPagado(false);
		} else {
			entrada.setPagado(false);
			entrada.setSaldo(entrada.getCuota());
			Calendar c = new GregorianCalendar();
			c.setTime(fechaInicio);
			c.add(Calendar.DATE, 15);
			entrada.setFechamora(c.getTime());
			entradaReporte.setPagado(false);
			egreso.addEntrada(entrada);
		}
		entradaReporte.setFecha(entrada.getFechalimite());
		entradaReporte.setCuota(entrada.getCuota());

		if (tiposPago.getTipopagoid() != 0)
			entradaReporte.setTipoPago(tipoPagoService.obtenerPorTipoPagoId(
					tiposPago.getTipopagoid()).getNombre());

		BigDecimal tm = new BigDecimal("0");
		List<Entrada> list = egreso.getEntradas();
		for (Entrada e : list)
			tm = tm.add(e.getCuota());

		totalMonto = tm;
		restante = restanteAux = cantidadFacturaCalculos.getTotal().subtract(
				totalMonto);
		if (totalMonto.compareTo(cantidadFacturaCalculos.getTotal()) > 0)
			cambio = totalMonto.subtract(cantidadFacturaCalculos.getTotal());

		listaEntradaReporte.add(entradaReporte);

	}

	public void calcularPrecioCantidad() {
		egresoService.calcularPrecioCantidad(facturaReporte);
	}

	public void calcularPrecioPromocion() {
		egresoService
				.calcularPrecioPromocion(facturaReporte, producto.getIva());
	}

	public void calcularPrecioSubTotal() {
		egresoService.calcularDescuentoPorcentaje(facturaReporte);
	}

	public void calcularPrecioTotal() {
		egresoService.calcularPrecioTotal(facturaReporte);
	}

	public void calcularPrecioUnit() {
		egresoService.calcularPrecioUnit(facturaReporte);
	}

	public void cambiarCantidad() {
		FacturaReporte f = listaFacturaReporte.get(fila);
		int can = kardexService.obtenerSaldoActual(f.getCodigo(),
				bodega.getBodegaid()).getCantidad();
		if (cantidad > can || cantidad <= 0)
			presentaMensaje(FacesMessage.SEVERITY_ERROR,
					"INGRESE UNA CANTIDAD MENOR O IGUAL A LA EXISTENTE: " + can
							+ " O MAYOR QUE CERO");
		else
			egresoService.recalcularCantidad(fila, listaFacturaReporte,
					egreso.getDetalleegresos(), cantidadFacturaCalculos,
					cantidad, false);

		cantidad = null;
		fila = null;
	}

	public void cambiarDescuento() {
		egresoService.cambiarDescuentoNotaEntrega(cantidadFacturaCalculos,
				cantidadFacturaPresentar);
	}

	public void cambiarPrecio() {
		egresoService.recalcularPrecio(fila, bodega.getBodegaid(),
				listaFacturaReporte, egreso.getDetalleegresos(),
				cantidadFacturaCalculos, nuevoPrecio, true);
		nuevoPrecio = null;
		fila = null;
	}

	public void cancelar() {
		facturaReporte = new FacturaReporte();
	}

	public void cancelarEntrada() {
		entrada = new Entrada();
		pagosEntrada = new Pagoentrada();
		tiposPago = new Tipopago();
	}

	public void cancelarPago() {
		listaEntradaReporte = new ArrayList<EntradaReporte>();
		egreso.setEntradas(new ArrayList<Entrada>());
		cambio = newBigDecimal();
		restante = cantidadFacturaCalculos.getTotal();
		cancelarEntrada();
	}

	public void cancelarTodo() {
		bn = true;
		limpiarObjetos();
		cliente = new Persona();
		entrada = new Entrada();
		pagosEntrada = new Pagoentrada();
		fechaInicio = new Date();
		listaEntradaReporte = new ArrayList<EntradaReporte>();
		listaFacturaReporte = new ArrayList<FacturaReporte>();
		cantidadFacturaCalculos = new CantidadFactura();
		restante = newBigDecimal();
		cambio = newBigDecimal();
	}

	public void cargarCliente(SelectEvent event) {
		cliente = clienteService.obtenerPorPersonaId(cliente.getPersonaid());
		egreso.setCliente(cliente.getCliente());
	}

	public void cargarProducto(SelectEvent event) {
		producto = productoService.obtenerPorProductoId(producto
				.getProductoid());
		facturaReporte.setProductoId(producto.getProductoid());
		Integer precioId = productoService.obtenerPvpPorProducto(producto
				.getTipoPrecioProductos());
		if (precioId == null) {
			precioId = producto.getTipoPrecioProductos().get(0)
					.getTipoprecioproductoid();
			presentaMensaje(FacesMessage.SEVERITY_WARN,
					"EL PRODUCTO NO TIENE CONFIGURADO EL PVP");
		}
		facturaReporte.setPrecioId(precioId);

		obtenerPrecio();
	}

	public boolean comprobar() {
		RequestContext context = RequestContext.getCurrentInstance();
		boolean bn = false;
		if (egreso.getCliente() == null) {
			bn = true;
			presentaMensaje(FacesMessage.SEVERITY_ERROR,
					"DEBE INGRESAR UN CLIENTE");
		}
		if (egreso.getDetalleegresos().isEmpty()) {
			bn = true;
			presentaMensaje(FacesMessage.SEVERITY_ERROR,
					"DEBE INGRESAR DETALLES");
		}
		if (vendedor.getEmpleadocargoid() == 0) {
			bn = true;
			presentaMensaje(FacesMessage.SEVERITY_ERROR,
					"DEBE INGRESAR UN VENDEDOR");
		}

		context.addCallbackParam("error2", bn);

		return bn;
	}

	public boolean comprobarCantidadFinal() {
		boolean bn = true;

		List<Detalleegreso> detalleEgreso = egresoService
				.duplicarDetalleEgreso(egreso.getDetalleegresos());

		List<Detalleegreso> detalleEgresoFinal = egresoService
				.sumarCantidades(detalleEgreso);
		for (Detalleegreso de : detalleEgresoFinal) {

			Producto producto = productoService.obtenerPorProductoId(de
					.getProducto().getProductoid());

			int cantidad = kardexService.obtenerSaldoActual(producto.getEan(),
					bodega.getBodegaid()).getCantidad();

			if (de.getCantidad() > cantidad) {
				bn = false;
				presentaMensaje(
						FacesMessage.SEVERITY_ERROR,
						"LA SUMA DE LAS CANTIDADES DEL PRODUCTO: "
								+ producto.getEan() + " ES MAYOR A: "
								+ cantidad);
			}
		}

		return bn;
	}

	public void comprobarLocal() {
		RequestContext context = RequestContext.getCurrentInstance();
		boolean bn = true;
		if (egreso.getLocal().getLocalid() == null) {
			bn = false;
			presentaMensaje(FacesMessage.SEVERITY_ERROR, "ESCOJA UN LOCAL");
		} else
			limpiarObjetosBusquedaProductos();

		context.addCallbackParam("error1", bn);
	}

	public void comprobarPrecioCosto() {
		BigDecimal precio = productoService.obtenerPorProductoId(
				facturaReporte.getProductoId()).getPrecio();
		if (facturaReporte.getPrecioUnitVenta().compareTo(precio) < 0)
			presentaMensaje(FacesMessage.SEVERITY_ERROR,
					"EL PRECIO NO DEBE SER MENOR AL PRECIO DE COSTO: " + precio);
		else {
			if (facturaReporte.getCantidad() != null)
				facturaReporte = egresoService.calcularTotales(facturaReporte);

			if (facturaReporte.getIva().compareToIgnoreCase("I") == 0)
				facturaReporte.setPrecioUnitIva(iva(facturaReporte
						.getPrecioUnitVenta()));
			else
				facturaReporte.setPrecioUnitIva(newBigDecimal());

			facturaReporte.setPrecioUnitTotal(redondear(facturaReporte
					.getPrecioUnitVenta()
					.add(facturaReporte.getPrecioUnitIva())));
		}
	}

	public void convertirNotaEntrega(Egreso e) {
		cancelarTodo();
		this.egreso = egresoService.obtenerPorEgresoId(e.getEgresoid());
		cliente = e.getCliente().getPersona();
		vendedor = e.getVendedorid();
		obtenerBodega();
		cantidadFacturaCalculos.setDescuentoEgreso(this.egreso.getDescuento());
		List<Detalleegreso> list = egreso.getDetalleegresos();
		for (Detalleegreso detalleEgreso : list) {
			FacturaReporte fr = egresoService.asignar(detalleEgreso, null, 8);

			cantidadFacturaCalculos = egresoService
					.calcularCantidadNotaEntrega(cantidadFacturaCalculos, fr,
							"add");
			listaFacturaReporte.add(fr);
		}
	}

	public void eliminarDetalle(ActionEvent actionEvent) {
		int posicion = egresoService.posicion(facturaReporte,
				egreso.getDetalleegresos(), false);
		if (posicion >= 0) {
			Detalleegreso de = egreso.getDetalleegresos().get(posicion);
			presentaMensaje(FacesMessage.SEVERITY_INFO, "ELIMINÓ EL PRODUCTO: "
					+ de.getProducto().getNombreimprimir());
			egreso.removeDetalleegreso(de);
			cantidadFacturaCalculos = egresoService
					.calcularCantidadNotaEntrega(cantidadFacturaCalculos,
							facturaReporte, "subtract");
			restante = restanteAux = cantidadFacturaCalculos.getTotal();
			listaFacturaReporte.remove(facturaReporte);
			cancelar();
		}
	}

	public BigDecimal getCambio() {
		return cambio;
	}

	public Integer getCantidad() {
		return cantidad;
	}

	public CantidadFactura getCantidadFacturaCalculos() {
		return cantidadFacturaCalculos;
	}

	public CantidadFactura getCantidadFacturaPresentar() {
		return egresoService.redondearCantidadFactura(cantidadFacturaPresentar,
				cantidadFacturaCalculos);
	}

	public Persona getCliente() {
		return cliente;
	}

	public String getCriterioClienteBusqueda() {
		return criterioClienteBusqueda;
	}

	public String getCriterioProductoBusqueda() {
		return criterioProductoBusqueda;
	}

	public Egreso getEgreso() {
		return egreso;
	}

	public Entrada getEntrada() {
		if (entrada.getPagoentradas() == null)
			entrada.setPagoentradas(new ArrayList<Pagoentrada>());
		return entrada;
	}

	public FacturaReporte getFacturaReporte() {
		return facturaReporte;
	}

	public Date getFechaInicio() {
		return fechaInicio;
	}

	public List<Persona> getListaClienteBusqueda() {
		return listaClienteBusqueda;
	}

	public List<EntradaReporte> getListaEntradaReporte() {
		return listaEntradaReporte;
	}

	public List<FacturaReporte> getListaFacturaReporte() {
		return listaFacturaReporte;
	}

	public List<Local> getListaLocales() {
		return listaLocales;
	}

	public List<Producto> getListaProductoBusqueda() {
		return listaProductoBusqueda;
	}

	public List<PersonaCedulaNombre> getListaVendedores() {
		return listaVendedores;
	}

	public List<Tipopago> getListTiposPago() {
		listTiposPago = tipoPagoService.obtener();
		return listTiposPago;
	}

	public BigDecimal getNuevoPrecio() {
		return nuevoPrecio;
	}

	public Pagoentrada getPagosEntrada() {
		return pagosEntrada;
	}

	public Producto getProducto() {
		return producto;
	}

	public BigDecimal getRestante() {
		restante = redondearTotales(restante);
		return restante;
	}

	public BigDecimal getRestanteAux() {
		return restanteAux;
	}

	public Tipopago getTiposPago() {
		return tiposPago;
	}

	public BigDecimal getTotalMonto() {
		return totalMonto;
	}

	public Empleadocargo getVendedor() {
		return vendedor;
	}

	public void imprimirNotaEntrega() {
		List<FacturaReporte> list = new ArrayList<FacturaReporte>();
		for (int i = 0; i < egreso.getDetalleegresos().size(); i++)
			list.add(egresoService.asignar(egreso.getDetalleegresos().get(i),
					listaFacturaReporte.get(i), 8));

		egresoReport.reporteNotaEntrega(egreso,
				clienteService.obtenerPorPersonaId(cliente.getPersonaid()),
				cantidadFacturaCalculos, list);
		cancelarTodo();
	}

	@PostConstruct
	public void init() {
		listaVendedores = empleadoService.obtenerPorCargo(5);
		setListaLocales(localService.obtenerPorCajero(SecurityContextHolder
				.getContext().getAuthentication().getName()));
		limpiarObjetos();
	}

	public void insertarDetalle(ActionEvent actionEvent) {
		if (producto == null)
			presentaMensaje(FacesMessage.SEVERITY_ERROR, "ESCOJA UN PRODUCTO");
		else {
			producto = productoService.obtenerPorProductoId(producto
					.getProductoid());

			Kardex kardex = kardexService.obtenerSaldoActual(producto.getEan(),
					bodega.getBodegaid());

			facturaReporte.setPrecioUnitVenta(facturaReporte
					.getPrecioUnitTotal());

			if (facturaReporte.getPrecioUnitVenta().compareTo(
					kardex.getPrecio()) < 0)
				presentaMensaje(FacesMessage.SEVERITY_ERROR,
						"EL PRECIO NO DEBE SER MENOR AL PRECIO DE COSTO");
			else if (facturaReporte.getCantidad() > kardex.getCantidad()
					&& facturaReporte.getCantidad() <= 0)
				presentaMensaje(
						FacesMessage.SEVERITY_ERROR,
						"INGRESE UNA CANTIDAD MENOR A LA EXISTENTE: "
								+ kardex.getCantidad() + " O MAYOR QUE CERO");
			else {
				Detalleegreso detalleEgreso = new Detalleegreso();

				detalleEgreso.setProducto(producto);

				facturaReporte = egresoService.asignar(detalleEgreso,
						facturaReporte, 0);

				detalleEgreso.setCantidad(facturaReporte.getCantidad());
				detalleEgreso.setPreciocosto(kardex.getPrecio());

				BigDecimal precioVenta = newBigDecimal();
				if (producto.getIva() && !facturaReporte.isPromocion())
					precioVenta = divide(facturaReporte.getPrecioUnitVenta(),
							new BigDecimal("1.12"));
				else
					precioVenta = facturaReporte.getPrecioUnitVenta();
				detalleEgreso.setPrecioventa(precioVenta);

				detalleEgreso
						.setDescuento(facturaReporte.getDescuentoDolares());
				detalleEgreso.setIva(producto.getIva());
				detalleEgreso.setPromocion(facturaReporte.isPromocion());
				detalleEgreso.setEliminar(facturaReporte.isEliminar());

				cantidadFacturaCalculos = egresoService
						.calcularCantidadNotaEntrega(cantidadFacturaCalculos,
								facturaReporte, "add");

				listaFacturaReporte.add(facturaReporte);
				egreso.addDetalleegreso(detalleEgreso);

				restante = restanteAux = cantidadFacturaCalculos.getTotal();
				presentaMensaje(FacesMessage.SEVERITY_INFO,
						"INSERTÓ EL PRODUCTO: " + producto.getNombreimprimir());
				limpiarObjetosBusquedaProductos();
				bnLocal = true;
			}
		}
	}

	public void insertarOrActualizar(ActionEvent actionEvent) {
		if (comprobarCantidadFinal() && !comprobar()) {
			bn = false;

			boolean pagado = true;
			List<Entrada> list = egreso.getEntradas();
			if (list.isEmpty())
				pagado = false;
			else {
				BigDecimal monto = newBigDecimal();
				for (Entrada e : list)
					if (e.getPagado() == true)
						monto = monto.add(e.getCuota());
				if (monto.compareTo(cantidadFacturaCalculos.getTotal()) < 0)
					pagado = false;
			}

			egreso.setPagado(pagado);

			if (egreso.getEgresoid() == null) {
				egreso.setVendedorid(vendedor);
				egresoService.insertar(egreso, bodega);
				presentaMensaje(
						FacesMessage.SEVERITY_INFO,
						"INSERTÓ LA NOTA DE ENTREGA: "
								+ egreso.getCodigodocumento());
			} else if (egreso.getTipodocumento().getTipodocumentoid() != 8) {
				egreso.setVendedorid(vendedor);
				egresoService.insertar(egresoService.duplicarEgreso(egreso, 8),
						bodega);
				presentaMensaje(
						FacesMessage.SEVERITY_INFO,
						"INSERTÓ LA NOTA DE ENTREGA: "
								+ egreso.getCodigodocumento());
			} else {
				egresoService.actualizar(egreso, bodega);
				presentaMensaje(
						FacesMessage.SEVERITY_INFO,
						"ACTUALIZO LA NOTA DE ENTREGA: "
								+ egreso.getCodigodocumento());
			}
		}

	}

	public boolean isBn() {
		return bn;
	}

	public boolean isBnLocal() {
		return bnLocal;
	}

	private void limpiarObjetos() {
		setBnLocal(false);
		egreso = new Egreso();
		egreso.setLocal(new Local());
		// egreso.setVendedor(new Vendedor());
		egreso.setEntradas(new ArrayList<Entrada>());
		egreso.setDetalleegresos(new ArrayList<Detalleegreso>());
		egreso.setTipodocumento(tipoDocumentoService.obtenerPorId(8));
		egreso.setCodigodocumento(tipoDocumentoService
				.obtenerPorId(8)
				.getAbreviatura()
				.concat("-")
				.concat(String.format("%010d",
						parametro.getSecuenciaentrega() + 1)));
		vendedor = new Empleadocargo();

		if (listaLocales.size() == 1) {
			egreso.setLocal(listaLocales.get(0));
			obtenerBodega();
			setBnLocal(true);
		}
	}

	public void limpiarObjetosBusquedaCliente() {
		criterioClienteBusqueda = new String();
		listaClienteBusqueda = new ArrayList<Persona>();
	}

	public void limpiarObjetosBusquedaProductos() {
		criterioProductoBusqueda = new String();
		// listaProductoBusqueda = new ArrayList<Producto>();
		producto = new Producto();
		facturaReporte = new FacturaReporte();
	}

	public void obtenerBodega() {
		Local local = localService.obtenerPorLocalId(egreso.getLocal()
				.getLocalid());
		if (local.getBodegalocals() != null
				&& !local.getBodegalocals().isEmpty())
			bodega = local.getBodegalocals().get(0).getBodega();
	}

	public void obtenerClientesPorBusqueda() {
		setListaClienteBusqueda(clienteService.obtener(criterioClienteBusqueda));
	}

	public void obtenerFila(CellEditEvent event) {
		fila = event.getRowIndex();
	}

	public void obtenerPrecio() {
		facturaReporte.setPrecioUnitVenta(productoService.calcularPrecio(
				producto, bodega.getBodegaid(), facturaReporte.getPrecioId()));

		facturaReporte.setIva(facturaReporte.isPromocion() ? "" : producto
				.getIva() ? "I" : "");

		if (facturaReporte.getCantidad() != null)
			facturaReporte = egresoService.calcularTotales(facturaReporte);

		facturaReporte.setPrecioUnitIva(facturaReporte.getIva()
				.compareToIgnoreCase("I") == 0 ? iva(facturaReporte
				.getPrecioUnitVenta()) : newBigDecimal());

		facturaReporte.setPrecioUnitTotal(redondear(facturaReporte
				.getPrecioUnitVenta().add(facturaReporte.getPrecioUnitIva())));
	}

	public void obtenerProductosPorBusqueda() {
		listaProductoBusqueda = productoService.obtenerPorLocal(
				criterioProductoBusqueda, egreso.getLocal().getLocalid());
	}

	public void setBn(boolean bn) {
		this.bn = bn;
	}

	public void setBnLocal(boolean bnLocal) {
		this.bnLocal = bnLocal;
	}

	public void setCambio(BigDecimal cambio) {
		this.cambio = cambio;
	}

	public void setCantidad(Integer cantidad) {
		this.cantidad = cantidad;
	}

	public void setCantidadFacturaCalculos(
			CantidadFactura cantidadFacturaCalculos) {
		this.cantidadFacturaCalculos = cantidadFacturaCalculos;
	}

	public void setCantidadFacturaPresentar(
			CantidadFactura cantidadFacturaPresentar) {
		this.cantidadFacturaPresentar = cantidadFacturaPresentar;
	}

	public void setCliente(Persona cliente) {
		this.cliente = cliente;
	}

	public void setCriterioClienteBusqueda(String criterioClienteBusqueda) {
		this.criterioClienteBusqueda = criterioClienteBusqueda;
	}

	public void setCriterioProductoBusqueda(String criterioProductoBusqueda) {
		this.criterioProductoBusqueda = criterioProductoBusqueda;
	}

	public void setEgreso(Egreso egreso) {
		this.egreso = egreso;
	}

	public void setEntrada(Entrada entrada) {
		this.entrada = entrada;
	}

	public void setFacturaReporte(FacturaReporte facturaReporte) {
		this.facturaReporte = facturaReporte;
	}

	public void setFechaInicio(Date fechaInicio) {
		this.fechaInicio = fechaInicio;
	}

	public void setListaClienteBusqueda(List<Persona> listaClienteBusqueda) {
		this.listaClienteBusqueda = listaClienteBusqueda;
	}

	public void setListaEntradaReporte(List<EntradaReporte> listaEntradaReporte) {
		this.listaEntradaReporte = listaEntradaReporte;
	}

	public void setListaFacturaReporte(List<FacturaReporte> listaFacturaReporte) {
		this.listaFacturaReporte = listaFacturaReporte;
	}

	public void setListaLocales(List<Local> listaLocales) {
		this.listaLocales = listaLocales;
	}

	public void setListaProductoBusqueda(List<Producto> listaProductoBusqueda) {
		this.listaProductoBusqueda = listaProductoBusqueda;
	}

	public void setListaVendedores(List<PersonaCedulaNombre> listaVendedores) {
		this.listaVendedores = listaVendedores;
	}

	public void setListTiposPago(List<Tipopago> listTiposPago) {
		this.listTiposPago = listTiposPago;
	}

	public void setNuevoPrecio(BigDecimal nuevoPrecio) {
		this.nuevoPrecio = nuevoPrecio;
	}

	public void setPagosEntrada(Pagoentrada pagosEntrada) {
		this.pagosEntrada = pagosEntrada;
	}

	public void setProducto(Producto producto) {
		this.producto = producto;
	}

	public void setRestante(BigDecimal restante) {
		this.restante = restante;
	}

	public void setRestanteAux(BigDecimal restanteAux) {
		this.restanteAux = restanteAux;
	}

	public void setTiposPago(Tipopago tiposPago) {
		this.tiposPago = tiposPago;
	}

	public void setTotalMonto(BigDecimal totalMonto) {
		this.totalMonto = totalMonto;
	}

	public void setVendedor(Empleadocargo vendedor) {
		this.vendedor = vendedor;
	}

}